package prestar.dominio.controladores;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import prestar.dominio.Mora;
import prestar.dominio.entidades.*;

public class Financiera 
{
    private int codigo;
    
    private String nombre;

    private String direccion;

    private String rnc;

    private static Financiera instancia;

    private Caja caja;

    private Financiamiento financiamiento;
    
    private Usuario usuario;

    private Cobro cobro;
    
    private Mora mora = new Mora();
    
    private List<Telefono> telefonos = new ArrayList<Telefono>();
    
    private String rootDir = System.getProperty("user.dir") + System.getProperty("file.separator") + "reportes" + System.getProperty("file.separator");
    

    public Financiera() {
        this.financiamiento = new Financiamiento();
    }

    public int getCodigo() {
        return codigo;
    }

    public void setCodigo(int codigo) {
        this.codigo = codigo;
    }

    public List<Telefono> getTelefonos() {
        return telefonos;
    }

    public void setTelefonos(List<Telefono> telefonos) {
        this.telefonos = telefonos;
    }
    
    public String[][] getTelefonosAsArray() {
        String[][] result = new String[this.getTelefonos().size()][];
        for (Telefono t : this.getTelefonos())
            result[this.getTelefonos().indexOf(t)] = new String[]{t.getTipo(), t.getNumero()};
        return result;
    }

    public Caja getCaja() {
        return caja;
    }

    public Mora getMora() {
        return mora;
    }

    public void setMora(Mora mora) {
        this.mora = mora;
    }
    
    public Usuario getUsuario() {
        return usuario;
    }

    public void setUsuario(Usuario usuario) {
        this.usuario = usuario;
    }

    public void setCaja(Caja caja) {
        this.caja = caja;
    }

    public String getDireccion() {
        return direccion;
    }

    public void setDireccion(String direccion) {
        this.direccion = direccion;
    }

    public Financiamiento getFinanciamiento() {        
        return this.financiamiento;
    }
    
    public Financiamiento getFinanciamiento(int codigo) {        
        
        Session se = prestar.mapeos.HibernateUtil.getSessionFactory().getCurrentSession();
        Financiamiento fin = null;

        org.hibernate.Transaction tr = se.beginTransaction();             
        fin = (Financiamiento) se.get(Financiamiento.class, codigo);
        fin.getCliente().getNombre();
        fin.getCobrador().getNombre();
        fin.getGarante().getNombre();
        fin.getCuotasAsArray();
        tr.commit();
        return fin;
    }

    public List<Financiamiento> getFinanciamientos() {
        
        List<Financiamiento> financ = null;
        
        Session se = prestar.mapeos.HibernateUtil.getSessionFactory().getCurrentSession();
        org.hibernate.Transaction tr = se.beginTransaction();
        Query q = se.createQuery("From Financiamiento");
        financ = (List<Financiamiento>) q.list();
        for (Financiamiento f : financ)
        {
            for (Cuota c : f.getCuotas())
            {
                for (ItemCobro i : c.getCobros())
                {
                    i.getCodigo();
                    i.getCuota();
                    i.getMonto();
                }
            }
        }
        tr.commit();
        
        return financ;
    }
    public List<Financiamiento> getFinanciamientos(int cliente) {
        
        List<Financiamiento> financ = null;
        
        Session se = prestar.mapeos.HibernateUtil.getSessionFactory().getCurrentSession();
        org.hibernate.Transaction tr = se.beginTransaction();
        Query q = se.createQuery("From Financiamiento AS f WHERE f.cliente = " + cliente);
        financ = (List<Financiamiento>) q.list();
        tr.commit();
        
        return financ;
    }
    public String[][] getFinanciamientosAsArray(int cliente) {
        List<Financiamiento> financiamientos = this.getFinanciamientos(cliente);
        String[][] arrayFinanciamientos = new String[financiamientos.size()][];
        
        for (Financiamiento f : financiamientos)
        {
            arrayFinanciamientos[financiamientos.indexOf(f)] = new String[]{String.valueOf(f.getCodigo()), String.valueOf(f.getCapital())};
        }
        
        return arrayFinanciamientos;
    }
    public String[][] getFinanciamientosAsArray() {
        List<Financiamiento> financiamientos = this.getFinanciamientos();
        String[][] arrayFinanciamientos = new String[financiamientos.size()][];
        
        for (Financiamiento f : financiamientos)
        {
            arrayFinanciamientos[financiamientos.indexOf(f)] = new String[]{String.valueOf(f.getCodigo()),
                util.Fechas.stringValue(f.getFecha()), String.valueOf(f.getTipo()), String.valueOf(f.getTasa().getCantidad()),
                String.valueOf(f.getPlazo().getCantidad()), f.getFrecCuotas(), "Cuotas", 
                String.valueOf(f.getCapital()), String.valueOf(f.valorPendiente()), 
                String.valueOf(f.totalCobrado()), String.valueOf(f.valorDelPrestamo())};
        }
        
        return arrayFinanciamientos;
    }
    public List<Cobro> getCobros() {
        
        List<Cobro> cobr = null;
        
        Session se = prestar.mapeos.HibernateUtil.getSessionFactory().getCurrentSession();
        org.hibernate.Transaction tr = se.beginTransaction();
        Query q = se.createQuery("From Cobro");
        cobr = (List<Cobro>) q.list();
        for (Cobro c : cobr)
        {
            if (c.getCliente() != null)
            {
                c.getCliente().getCodigo();
                c.getCliente().getNombre();
                c.getCliente().getApellido();
            }
            c.total();
        }
        tr.commit();
        
        return cobr;
    }
    public List<Cobro> getCobros(int cliente) {
        
        List<Cobro> cob = null;
        
        Session se = prestar.mapeos.HibernateUtil.getSessionFactory().getCurrentSession();
        org.hibernate.Transaction tr = se.beginTransaction();
        Query q = se.createQuery("From Cobro AS c WHERE c.cliente = " + cliente);
        cob = (List<Cobro>) q.list();
        tr.commit();
        
        return cob;
    }
    public String[][] getCobrosAsArray(int cliente) {
        List<Cobro> cobros = this.getCobros(cliente);
        String[][] arrayCobros = new String[cobros.size()][];
        
        for (Cobro c : cobros)
        {
            arrayCobros[cobros.indexOf(c)] = new String[]{String.valueOf(c.getCodigo()), String.valueOf(c.getFecha())};
        }
        
        return arrayCobros;
    }
    public String[][] getCobrosAsArray() {
        List<Cobro> cobros = this.getCobros();
        String[][] arrayCobros = new String[cobros.size()][];
        
        for (Cobro c : cobros)
        {
            if (c.getCliente() != null)
            {
                arrayCobros[cobros.indexOf(c)] = new String[]{String.valueOf(c.getCodigo()), util.Fechas.stringValue(c.getFecha()),
                String.valueOf(c.getCliente().getCodigo()) + " " +  c.getCliente().getNombre() + " " +  
                c.getCliente().getApellido(), String.valueOf(c.total()), "No sabemos"};
            }
        }
        
        return arrayCobros;
    }
    public void setFinanciamiento(Financiamiento financiamiento) {
        this.financiamiento = financiamiento;
    }

    public static Financiera getInstancia() {
        if (Financiera.instancia == null)
        {
            Session se = prestar.mapeos.HibernateUtil.getSessionFactory().getCurrentSession();
            org.hibernate.Transaction tr = se.beginTransaction();             
            //Financiera.instancia = (Financiera) se.get(Financiera.class, 5);
            Query q = se.createQuery("From Financiera");
            Financiera.instancia = (Financiera)q.uniqueResult();
            if (Financiera.instancia != null)
                Financiera.instancia.getTelefonosAsArray();
            else
                Financiera.instancia = new Financiera();
            tr.commit();
        }
        return instancia;
    }
    private boolean isNew()
    {
        return Financiera.getInstancia().getCodigo() < 1;
    }
    public void guardarConfiguracion()
    {
        Session se = prestar.mapeos.HibernateUtil.getSessionFactory().getCurrentSession();
        org.hibernate.Transaction tr = se.beginTransaction();
        if (Financiera.getInstancia().isNew())
            se.save(Financiera.getInstancia());
        else
            se.update(Financiera.getInstancia());
        tr.commit();
    }

    public static void setInstancia(Financiera instancia) {        
        Financiera.instancia = instancia;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public String getRnc() {
        return rnc;
    }

    public void setRnc(String rnc) {
        this.rnc = rnc;
    }
    
    public List<Cliente> getClientes() {
        Session se = prestar.mapeos.HibernateUtil.getSessionFactory().getCurrentSession();
        List<Cliente> personas = null;

        org.hibernate.Transaction tr = se.beginTransaction();             
        Query q = se.createQuery("From Cliente as cliente");
        personas = (List<Cliente>) q.list();
        tr.commit();
        return personas;
    }
    public String[][] getClientesAsArray() {
        List<Cliente> clientes = this.getClientes();
        String[][] arrayClientes = new String[clientes.size()][];
        
        for (Cliente c : clientes)
        {
            arrayClientes[clientes.indexOf(c)] = new String[]{String.valueOf(c.getCodigo()), c.getNombre(), c.getApellido(), 
                c.getCedula(), c.getDireccion()};
        }
        
        return arrayClientes;
    }
    
    public Cliente getCliente(int codigo) {
        Session se = prestar.mapeos.HibernateUtil.getSessionFactory().getCurrentSession();
        Cliente client = null;

        org.hibernate.Transaction tr = se.beginTransaction();             
        client = (Cliente) se.get(Cliente.class, codigo);
        client.getTelefonosAsArray();
        for (Financiamiento f: client.getprestamos())
            f.getCuotasAsArray();
        tr.commit();
        
        return client;
    }
    
    public List<Garante> getGarantes() {
        Session se = prestar.mapeos.HibernateUtil.getSessionFactory().getCurrentSession();
        List<Garante> personas = null;

        org.hibernate.Transaction tr = se.beginTransaction();             
        Query q = se.createQuery("From Garante as garante");
        personas = (List<Garante>) q.list();
        tr.commit();
        return personas;
    }
    public String[][] getGarantesAsArray() {
        List<Garante> garantes = this.getGarantes();
        String[][] arrayGarantes = new String[garantes.size()][];
        
        for (Garante g : garantes)
        {
            arrayGarantes[garantes.indexOf(g)] = new String[]{String.valueOf(g.getCodigo()), g.getNombre(), g.getApellido(), 
                g.getCedula(), g.getDireccion()};
        }
        
        return arrayGarantes;
    }
    public Garante getGarante(int codigo) {
        Session se = prestar.mapeos.HibernateUtil.getSessionFactory().getCurrentSession();
        Garante garante = null;

        org.hibernate.Transaction tr = se.beginTransaction();             
        garante = (Garante) se.get(Garante.class, codigo);
        garante.getTelefonosAsArray();
        
        tr.commit();
        
        return garante;
    }
    
    public List<Cobrador> getCobradores() {
        Session se = prestar.mapeos.HibernateUtil.getSessionFactory().getCurrentSession();
        List<Cobrador> personas = null;
        org.hibernate.Transaction tr = se.beginTransaction();             
        Query q = se.createQuery("From Cobrador as cobrador");
        personas = (List<Cobrador>) q.list();
        tr.commit();
        return personas;
    }
    
    public String[][] getCobradoresAsArray() {
        List<Cobrador> cobradores = this.getCobradores();
        String[][] arrayCobradores = new String[cobradores.size()][];
        
        for (Cobrador c : cobradores)
        {
            arrayCobradores[cobradores.indexOf(c)] = new String[]{String.valueOf(c.getCodigo()), c.getNombre(), c.getApellido(), 
                c.getCedula(), c.getDireccion()};
        }
        
        return arrayCobradores;
    }
    
    
    
    public List<Usuario> getUsuarios() {
        Session se = prestar.mapeos.HibernateUtil.getSessionFactory().getCurrentSession();
        List<Usuario> personas = null;
        org.hibernate.Transaction tr = se.beginTransaction();             
        Query q = se.createQuery("From Usuario as usuario");
        personas = (List<Usuario>) q.list();
        tr.commit();
        return personas;
    }
    
    public String[][] getUsuariosAsArray() {
        List<Usuario> usuarios = this.getUsuarios();
        String[][] arrayUsuarios = new String[usuarios.size()][];
        
        for (Usuario c : usuarios)
        {
            arrayUsuarios[usuarios.indexOf(c)] = new String[]{String.valueOf(c.getCodigo()), c.getNombre(), c.getApellido(), 
                c.getCedula(), c.getDireccion()};
        }
        
        return arrayUsuarios;
    }
    
    public Cobrador getCobrador(int codigo) {
        Session se = prestar.mapeos.HibernateUtil.getSessionFactory().getCurrentSession();
        Cobrador cobr = null;

        org.hibernate.Transaction tr = se.beginTransaction();             
        cobr = (Cobrador) se.get(Cobrador.class, codigo);
        cobr.getTelefonosAsArray();
        tr.commit();
        
        return cobr;
    }
    
    public Usuario getUsuario(int codigo) {
        Session se = prestar.mapeos.HibernateUtil.getSessionFactory().getCurrentSession();
        Usuario user = null;

        org.hibernate.Transaction tr = se.beginTransaction();             
        user = (Usuario) se.get(Usuario.class, codigo);
        user.getTelefonosAsArray();
        tr.commit();
        
        return user;
    }
    
    public boolean login(String nick, String clave) {
        boolean existe = false;
        int tamano;
        Session se = prestar.mapeos.HibernateUtil.getSessionFactory().getCurrentSession();
        org.hibernate.Transaction tr = se.beginTransaction();
        Query q = se.createQuery("From Usuario AS user WHERE user.nombreUsuario = '" + nick + "' AND user.clave = '" + clave + "'");
        existe = q.list().size() > 0;
        if (existe)
            this.setUsuario((Usuario)q.uniqueResult());
        tr.commit();
        return existe;
    }


    public void hacerFinanciamiento(String tip, String cap, String frecCuotas,
            String cantTasa, String frecTasa, String cantPlazo, String frecPlazo,
            String codCliente, String codGarante, String codCobrador)
    {
        String tipo = tip;
        float capital = Float.parseFloat(cap);
        float tasa = Float.parseFloat(cantTasa);
        String tipoInteres = frecTasa;
        int plazo = Integer.parseInt(cantPlazo);
        String tipoPlazo = frecPlazo;
        String frecuenciaPagos = frecCuotas;
        int cliente = Integer.parseInt(codCliente);
        int garante = Integer.parseInt(codGarante);
        int cobrador = Integer.parseInt(codCobrador);
        
        this.financiamiento = new Financiamiento(tipo, capital, frecuenciaPagos, 
                    tasa, tipoInteres, plazo, tipoPlazo, this.getCliente(cliente), 
                    this.getGarante(garante), this.getCobrador(cobrador));
        
    }
    
    public void setClienteFinanciamiento(Cliente c)
    {
        if (this.financiamiento == null)
            this.financiamiento = new Financiamiento();
        this.financiamiento.setCliente(c);
    }
    
    public void setGaranteFinanciamiento(Garante g)
    {
        this.financiamiento.setGarante(g);
    }
    
    public void setCobradorFinanciamiento(Cobrador c)
    {
        this.financiamiento.setCobrador(c);
    }
    
    public void imprimirFinanciamiento()
    {
        String fileName = this.rootDir + "Financiamiento.jasper";
        HashMap hm = new HashMap();
        hm.put("codFin", new Integer(this.financiamiento.getCodigo()));
        util.Printer.verReporte(fileName, hm);
    }
    
    public void imprimirFinanciamiento(Financiamiento f)
    {
        
        String fileName = this.rootDir +  "Financiamiento.jasper";
        HashMap hm = new HashMap();
        hm.put("codFin", new Integer(f.getCodigo()));
        util.Printer.verReporte(fileName, hm);
    }
    
    public void guardarFinanciamiento()
    {
        Session se = prestar.mapeos.HibernateUtil.getSessionFactory().getCurrentSession();
        org.hibernate.Transaction tr = se.beginTransaction();             
        se.save(this.financiamiento);
        tr.commit();        
    }
    
    public void guardarFinanciamiento(Financiamiento f)
    {
        Session se = prestar.mapeos.HibernateUtil.getSessionFactory().getCurrentSession();
        org.hibernate.Transaction tr = se.beginTransaction();             
        se.save(f);
        tr.commit();
    }
    
    public void guardarCliente(Cliente c)
    {
        Session se = prestar.mapeos.HibernateUtil.getSessionFactory().getCurrentSession();
        org.hibernate.Transaction tr = se.beginTransaction();
        if (c.isNew())
            se.save(c);
        else
            se.update(c);
        tr.commit();        
    }
    
    public void guardarCliente(String nombre, String apellido, String cedula, String direccion)
    {
        Cliente cliente = new Cliente(nombre, apellido, cedula, direccion);
        Session se = prestar.mapeos.HibernateUtil.getSessionFactory().getCurrentSession();
        org.hibernate.Transaction tr = se.beginTransaction();             
        se.save(cliente);
        tr.commit();        
    }
    public void guardarCliente(int codigo, String nombre, String apellido, String cedula, String direccion)
    {
        Session se = prestar.mapeos.HibernateUtil.getSessionFactory().getCurrentSession();
        org.hibernate.Transaction tr = se.beginTransaction();             
        Cliente cl = (Cliente) se.load(Cliente.class, codigo);
        cl.setNombre(nombre);
        cl.setApellido(apellido);
        cl.setCedula(cedula);
        cl.setDireccion(direccion);
        tr.commit();        
    }
    public void guardarGarante(Garante c)
    {
        Session se = prestar.mapeos.HibernateUtil.getSessionFactory().getCurrentSession();
        org.hibernate.Transaction tr = se.beginTransaction();
        if (c.isNew())
            se.save(c);
        else
            se.update(c);
        tr.commit();        
    }
    public void guardarGarante(String nombre, String apellido, String cedula, String direccion)
    {
        Garante garante = new Garante(nombre, apellido, cedula, direccion);
        Session se = prestar.mapeos.HibernateUtil.getSessionFactory().getCurrentSession();
        org.hibernate.Transaction tr = se.beginTransaction();             
        se.save(garante);
        tr.commit();        
    }
    public void guardarGarante(int codigo, String nombre, String apellido, String cedula, String direccion)
    {
        Session se = prestar.mapeos.HibernateUtil.getSessionFactory().getCurrentSession();
        org.hibernate.Transaction tr = se.beginTransaction();             
        Garante gar = (Garante) se.load(Garante.class, codigo);
        gar.setNombre(nombre);
        gar.setApellido(apellido);
        gar.setCedula(cedula);
        gar.setDireccion(direccion);
        tr.commit();        
    }
    
    public void guardarCobrador(Cobrador c)
    {
        Session se = prestar.mapeos.HibernateUtil.getSessionFactory().getCurrentSession();
        org.hibernate.Transaction tr = se.beginTransaction();
        if (c.isNew())
            se.save(c);
        else
            se.update(c);
        tr.commit();        
    }
    public void guardarCobrador(String nombre, String apellido, String cedula, String direccion)
    {
        Cobrador cobrador = new Cobrador(nombre, apellido, cedula, direccion);
        Session se = prestar.mapeos.HibernateUtil.getSessionFactory().getCurrentSession();
        org.hibernate.Transaction tr = se.beginTransaction();             
        se.save(cobrador);
        tr.commit();        
    }
    public void guardarCobrador(int codigo, String nombre, String apellido, String cedula, String direccion)
    {
        Session se = prestar.mapeos.HibernateUtil.getSessionFactory().getCurrentSession();
        org.hibernate.Transaction tr = se.beginTransaction();             
        Cobrador cob = (Cobrador) se.load(Cobrador.class, codigo);
        cob.setNombre(nombre);
        cob.setApellido(apellido);
        cob.setCedula(cedula);
        cob.setDireccion(direccion);
        tr.commit();        
    }
    public void guardarUsuario(Usuario c)
    {
        Session se = prestar.mapeos.HibernateUtil.getSessionFactory().getCurrentSession();
        org.hibernate.Transaction tr = se.beginTransaction();
        if (c.isNew())
            se.save(c);
        else
            se.update(c);
        tr.commit();        
    }
    public void guardarUsuario(String nombre, String apellido, String cedula, String direccion, String nombreUsuario, String clave, String permisos)
    {
        Usuario user = new Usuario(nombre, apellido, cedula, direccion, nombreUsuario, clave, permisos);
        Session se = prestar.mapeos.HibernateUtil.getSessionFactory().getCurrentSession();
        org.hibernate.Transaction tr = se.beginTransaction();             
        se.save(user);
        tr.commit();        
    }
    public void guardarUsuario(int codigo, String nombre, String apellido, String cedula, String direccion, String nombreUsuario, String clave, String permisos)
    {
        Session se = prestar.mapeos.HibernateUtil.getSessionFactory().getCurrentSession();
        org.hibernate.Transaction tr = se.beginTransaction();             
        Usuario user = (Usuario) se.load(Usuario.class, codigo);
        user.setNombre(nombre);
        user.setApellido(apellido);
        user.setCedula(cedula);
        user.setDireccion(direccion);
        user.setNombreUsuario(nombreUsuario);
        user.setClave(clave);
        user.setPermisos(permisos);
        tr.commit();        
    }
    public void eliminarCliente(Cliente cl)
    {
        Session se = prestar.mapeos.HibernateUtil.getSessionFactory().getCurrentSession();
        org.hibernate.Transaction tr = se.beginTransaction();
        se.delete(cl);
        tr.commit();    
    }
    
    public void eliminarGarante(Garante gar)
    {             
        Session se = prestar.mapeos.HibernateUtil.getSessionFactory().getCurrentSession();
        org.hibernate.Transaction tr = se.beginTransaction();
        se.delete(gar);
        tr.commit();    
    }
    
    public void eliminarCobrador(Cobrador cobrador)
    {             
        Session se = prestar.mapeos.HibernateUtil.getSessionFactory().getCurrentSession();
        org.hibernate.Transaction tr = se.beginTransaction();
        se.delete(cobrador);
        tr.commit();    
    }
    
    public void eliminarUsuario(Usuario u)
    {             
        Session se = prestar.mapeos.HibernateUtil.getSessionFactory().getCurrentSession();
        org.hibernate.Transaction tr = se.beginTransaction();
        se.delete(u);
        tr.commit();    
    }
    
    public void agregarCuota(Cuota c, double d)
    {
        if (this.cobro == null)
            this.cobro = new Cobro();
        this.cobro.agregarItem(c, d);
        
    }
    
    public void agregarItemDeCobro(Cuota c)
    {
        if (this.cobro == null)
            this.cobro = new Cobro();
        this.cobro.agregarItem(c);
    }
    
    public void agregarClienteDeCobro(Cliente c)
    {
        if (this.cobro == null)
            this.cobro = new Cobro();
        this.cobro.setCliente(c);
        
    }

    public Cobro getCobro() {
        return cobro;
    }
    public Cobro getCobro(int codigo) {
        
        Session se = prestar.mapeos.HibernateUtil.getSessionFactory().getCurrentSession();
        Cobro ingreso = null;

        org.hibernate.Transaction tr = se.beginTransaction();             
        ingreso = (Cobro) se.get(Cobro.class, codigo);
        ingreso.getCliente().getNombre();
        ingreso.getItemsArray();
        tr.commit();
        
        return ingreso;
    }
    public void setCobro(Cobro cobro) {
        this.cobro = cobro;
    }
    
    
    public void guardarCobro()
    {
        Session se = prestar.mapeos.HibernateUtil.getSessionFactory().getCurrentSession();
        org.hibernate.Transaction tr = se.beginTransaction();             
        se.save(this.cobro);
        tr.commit(); 
    }
    
    public void imprimirCobro()    
    {
        
        String fileName = this.rootDir + "ReciboIngreso.jasper";
        HashMap hm = new HashMap();
        hm.put("cobro", new Integer(this.cobro.getCodigo()));
        util.Printer.verReporte(fileName, hm);
    }
    public void imprimirCobro(Cobro c)    
    {
        
        String fileName = this.rootDir + "/ReciboIngreso.jasper";
        HashMap hm = new HashMap();
        hm.put("cobro", new Integer(c.getCodigo()));
        util.Printer.verReporte(fileName, hm);
    }
    public void efectuarPago(float efectivoOfrecido) 
    {
        this.cobro.efectuarPago(efectivoOfrecido);
        this.guardarCobro();
    }
    public void efectuarPago(long numTC, Date fechVenc, long numCed) 
    {
        this.cobro.efectuarPago(numTC, fechVenc, numCed);
        this.guardarCobro();
    }

    public void efectuarPago(long numCed) 
    {
        this.cobro.efectuarPago(numCed);
        this.guardarCobro();
    }
}
